// #include "functions.h"
// #include "leecode.h"

// #include <unordered_set>

// using namespace std;

//    struct Index{
//           int begin = -1;
//           int end = -1;
//           Index(const Index &other) {
//               begin = other.begin;
//               end = other.end;
//           }
//           Index() = default;
//           Index(int i , int j) : begin(i), end(j) {}

//           bool operator == (const Solution::Index& other) const {
//               return (begin == other.begin) && (end == other.end);
//           }
//           bool operator < (const  Solution::Index& other) const {
//             if(begin < other.begin)
//               return true;
//             else if((begin == other.begin) && (end < other.end))
//               return true;
//             return false;
//           }
//       };

//         static size_t Hash(const Index& key) {
//             return std::hash<int>()(key.begin * 1000 + key.end);
//           }

// class Solution {
// public:
// Solution() = default;
   

//     void find_longest(const char* sarray, int i,int k, int j, int &maxlen, int &begin_ret) {
//             while(k >= 0 && j < len) {
//                 bool ret = isParlin(sarray, k, j);
//                 if(!ret)
//                   break;
//                 else {
//                     if(maxlen < j - k+1) {
//                       maxlen = j - k+1;
//                       begin_ret = k;
//                     }
//                     k = k -1;
//                     j = j + 1;
//                 }
//             }
//         }

//     string longestPalindrome(string s) {
//         len = s.length();
//         if(len < 1 || len > 1000)
//           return string();
//         index_set.clear();
//         if(len <= 1)
//           return s;
        
//         const char* sarray = s.data();
//         int maxlen = 0;
//         int begin_ret = -1;

//         for(int i = 0; i < len; i++) {
//             find_longest(sarray, i, i, i+1, maxlen, begin_ret);
//             find_longest(sarray, i, i, i+2, maxlen, begin_ret);
//         }

//         if(maxlen == 0)
//           return s.substr(0, 1);

//         return s.substr(begin_ret, maxlen);
//     }

//     bool isParlin(const char *s, int i, int j) {
//         Index index(i, j);
//         if(index_set.find(index)!= index_set.end())
//           return true;
//         int x = j - i;
//         if(x == 1) {
//             if(s[i] == s[j]) {
//                  index_set.insert(index);
//                  return true;
//             } else {
//                 return false;
//             }
//         }
          
//         if(i == j)
//           return true;
//         else if(x <= 0)
//           return false;
        
//         if(s[i] != s[j]) {
//             return false;
//         } else {
//             index_set.insert(index);
//             return true;
//  //           if(index_set.find(Index(i+1, j-1))!= index_set.end()
//  //               || i+1 == j-1) {
//  //               index_set.insert(index);
//  //               return true;
//  //           }
//         }
//         return false;
//     }

//     void expect(std::string input,  std::string s) {
//     std::string ret = longestPalindrome(input);
//     if(ret == s)
//       printf("%s succeed\n", s.data());
//     else
//       printf("%s fail, ret is %s\n", s.data(), ret.data());
//   }
//     private:
//       int len;
//       std::unordered_set<Index, decltype(Hash)> index_set;
// };

// void longestPalindrome() {
//   Solution s;
//   s.expect("babad","bab" );
//   s.expect("cbbd","bb" );
// }


